Script/binary-encoded-character processing method and system

ABSTRACT

A pen-based processor needs to be usable to input and edit script in the manner of a text-based computer but retain a resemblance to the user much like a pad and pencil. The pen-based computer implements enable input, editing and other manipulation of handwritten script, ASCII text and drawings in a common document using a compatible internal representation of the data and a simple, consistent set of user control functions. These functions are invoked by the user with an intuitive and interactive set of user gestures which do not distract the user from the task of inputting or editing the document. A two-step gesture method avoids confusion between strokes and command gestures and allows similar gestures to be used for different functions within the same and different contexts. The system infers from customary user writing conventions that certain relationships of data are to be preserved and maintains the relationships, subject to user override, during editing. The display document is formatted to contain both lined areas of script, text and imbedded drawings that can be edited, including word wrapping, and adjoining unlined drawing areas that remain unaffected by editing of lined area contents.

BACKGROUND OF THE INVENTION

This invention relates generally to pen-based computer systems and moreparticularly to an interactive method for entry and editing of script,text and drawings in a document display.

Script refers to handwritten characters and words. Text refers totypewritten characters and words and includes binary-encoded characterssuch as ASCII text. Drawings refers to hand drawn sketches but can alsoinclude imported drawings originally drawn by or on a machine.

Existing pen-based systems use gestures to edit exclusively script orASCII text (i.e., not both interchangeably or simultaneously). They arelimited, moreover, to gestures that by their form, context, or locationcan be distinguished from the data that they act upon. For instance,free-form gestures applied to ASCII text are recognizable because theASCII exists in what can be termed a different plane. Free form gesturesapplied to selected script are recognizable because pen actionsfollowing a selection are assumed to be gestures OR because writingapplied to a selected area is assumed to be a gesture. Free-formgestures occurring within a gesture sensitive area of the screen areeasily recognized. Otherwise, prior systems require an explicit actionto initiate gesture recognition especially within script such asselection of text or scrip or keyboard or similar input of a controlcommand. One could alternatively designate a set of unique strokes todefine gesture commands, but this approach requires interpretation ofall strokes during script entry which is compute-intensive and virtuallyprecludes mixing script, ASCII text and sketches.

Editing of untranslated script in existing systems is typicallyrestricted to opening up space between characters or words, erasingcharacters or words, and applying enhancements to pieces of script(e.g., underline, bold, etc.). No known prior pen-based system enablesscript words to be word-wrapped, let alone doing it with mixed scriptand ASCII text. Developers have probably been reluctant to attemptscript word wrap for the following reasons:

Processing strokes consumes a lot of CPU time making it difficultwrapping reflow and display in a timely manner.

Strokes consume a lot of memory.

A word wrapping algorithm for handwritten script is unheard of, to saynothing of one that can maintain the user's spacing of strokes (words).

Certain pieces of information that delimit paragraphs and preservehorizontal/vertical whitespace during word wrap must somehow existwithin the script document. The common approach to adding this sort ofinformation to a document involves explicitly delimiting paragraphs andspecifying whitespace, neither of which is conducive to the free flow ofthoughts while writing.

Mixing ASCII and script text with graphics requires a gesture set thatfunctions the same with both types of text and is not confused withscript writing or graphics drawing. Mixing ASCII with script text in thesame edit plane is not known to have been done before, although systemsare known in which a script annotation plane allows users to overlayexisting ASCII documents with script comments.

ASCII text editing systems have typically been character-based, using acursor to control positioning. Script, by its nature, makescharacter-based editing very difficult. A cursor is not needed withscript because of the direct referencing characteristics of a pen. Asystem that mixes both script and ASCII text must be able to handle thecharacter nature of ASCII as well as the free-form nature of script.

Script is composed of strokes; pen movements captured as the stylustraces a character outline on a digitizing tablet. A script charactercan contain one or more strokes. Each stroke must be captured and itscharacteristics maintained in a stroke database. The typical method forthis is called the time-order method. The time-order method haslimitations, however. This method can lead to misinterpreted characters,depending on how the characters are created. Accordingly, a new approachis required which would eliminate the ordering of strokes merely by thepoint in time in which they are created.

Another drawback to current art for capturing pen-based stroke datainput is the inability of current systems to wrap words and maintainpredesignated spacing between words that have wrapped on to a subsequentline. This causes a loss of the user's writing characteristics,resulting in material that is less readable to the person who wrote it.Accordingly, a method is required to maintain predesignated spacebetween words after word wrapping to successive lines occurs.

A system could determine the amount of space between script words bymonitoring stroke data input in real time; analyzing the data usingpattern recognition techniques, and accordingly developing a method foridentifying word separation space. This, however, requires complexsoftware and hardware capability beyond that of the typical pen-basedtechnology commercially available. Accordingly, a method is requiredwhich reliably captures word spacing without complex computer analysisof stroke data.

Accordingly, a need remains for a better way to enter, store, manage andedit handwritten script, or preferably script and binary-encoded text,in a pen-based computer system.

SUMMARY OF THE INVENTION

One object of the invention is to provide an improved pen-based computersystem and script editing process.

Another object is to recognize stroke/ASCII character clusters or unitsthat might represent words or embedded drawings.

A related object is to ascertain word boundaries in order to performword editing functions such as word wrap while maintaining the user'sword spacing.

Another object is to provide an intuitive interactive user interface fora pen-based computer.

A further object is to specify editing commands within freeformscript/drawings such that the commands are not confused with thescript/drawings and the user interface retains the look and feel of apiece of paper.

An additional object is to interpret the meaning of script/ASCII textpositions within a document being written or a document that has beenscanned or FAXed and to provide editing features without destroying thesubtle information inherent in the layout of a page of text.

A script/binary-encoded-character processor (or simply script/textprocessor) preferably includes a script/ASCII text editor, support forcreating drawings, and optionally an outliner. The processor also hassimple page layout capabilities implemented through vertical andhorizontal margin settings.

The basic script or script/text processing method can be implemented ina variety of software forms suited to different operating systems suchas PenPoint from GO Corp. of Foster City, Calif., and PenWindows fromMicrosoft Corp. of Bellevue, Wash., or without an operating system butwith similar program features for accessing and controlling hardwarecomponents. The processor can provide character/word translation intoASCII text using, e.g., GO Corp. software. A wide range of hardwareconfigurations can be used to implement the processor of the invention.

Input to the script/text processor can take many forms: writing with apen (stylus) on a digitizer connected to a computer; existing or storeddocuments; documents from character (keyboard) based word processors;FAX transmissions and scanned documents. A word processor specificprogram converts the character-based document to a form recognizable bythe processor. The FAX contents are recognized by the script/textprocessor and converted to the processor document format. The samealgorithm that recognizes FAX contents will recognize the contents ofscanned images.

Output from the processor can likewise take many forms including:script/text documents; ASCII files; printed images; FAX transmissions.

Input/Output to the processor can be from/to a storage medium (e.g., adisk) or some sort of network connection (e.g., a LAN or telephonelines). The processor software can be implemented in a concurrentversion that allows multiple computer users to interactively edit thesame document.

One aspect of the invention is that an efficient stroke compressionalgorithm is provided, so that documents can contain many pages ofuntranslated script, as well as ASCII text. Since pen strokes can becaptured at high resolutions (200+ dots per inch), the method ofcompressing strokes was devised so as to retain the information neededto perform translation of script into "ASCII" characters. A method wasalso devised for converting FAX or scanned documents into thescript/text document format. The compression method commences with the"root" of each stroke, which is defined relative to the line space towhich the stroke is connected. Strokes are preferably rooted in the linespace where the pen first touched when the stroke was made, but a stroke"center of gravity" (or some similar type of algorithm) could also oralternatively be used to determine in which line a stroke should berooted. The method also allows ascenders and descenders (e.g., tail on"g") to cross over line boundaries while still remaining rooted in ahome line.

Another aspect of the invention is that the script/text processorrecognizes word boundaries within the script text and, preferably, canalso recognize the implicit layout of text lines within a document. Thisaspect enables the processor to provide editing/word processing featuresthat prior to this invention were not available for handwrittendocuments. It can also facilitate outlining. Additionally, because thescript/text processor of the invention can manipulate words as images,script or text containing more than one language (shorthand could beconsidered a different language) can be edited (provided both languagesuse similar editing conventions, such as word wrapping forward from theright end of a line of text).

The method for managing word wrapping presents a novel solution to thecurrent technical problems associated with determining word boundariesand managing word spacing. One aspect of the method provides a defaultword spacing value called a break point gap which can be assignedthrough a plurality of mechanisms at the outset of stroke data capture.Another aspect of the method employs a comparative analysis of whitespace between points of stroke data with the default break point gapvalue. A third aspect employs a monitoring mechanism for maintainingword spacing regardless of whether word wrapping has occurred.

Another aspect of the invention is a method that enables the user to usea single gesture set to manipulate both script and ASCII text, and evendrawings, all within a single document. Since word translation can occurin the background as the user writes, a document can contain both scriptand ASCII text. Or an ASCII document can be imported and edited, e.g.,by addition of script.

Other pen-based systems are known to use a set of stylus gestures forediting functions. Rather than limiting gestures to editing only ASCII,or to gestures formed so as not to be construed as script (whichinterferes with embedding drawings in a document), however, the presentinvention uses a two-step interactive approach to inputting andinterpreting an editing gesture. The first step is to initiate atransitory gesture mode prompt. Once that mode is initiated (and,preferably, but not essentially, a gesture prompt is displayed), asecond step is to accept a following stylus movement or gesture as acommand. Upon completion of the gesture, the gesture mode automaticallyterminates. This approach is functional for editing both script andASCII (any binary encoded text or data), and drawings as well.

Also, rather than using compound or unique gestures (e.g., a caret, apigtail, etc.), straightline vertical and horizontal gestures arepreferred. The gesture set used in the invention is selected toimplement an intuitive relationship between the gestures and therespective functions to be performed.

The gesture set is also context-sensitive as between text and graphicalediting, depending on whether the stylus is in a lined writing area oran open (unlined) drawing area of the document. Furthermore, differentinitial pen actions can be used to obtain different gesture modeprompts. In each case, subsequent gestures initiate different functions,depending on location/context and form of gesture prompt. This allows asimple set of gestures to be used easily to perform a variety offunctions. The gesture set allows quick and easy corrections of mistakesby the algorithms that recognize word boundaries and text layout.

Another aspect of the invention enables the user to enter scriptcontinually without having to explicitly request additional blank spaceor move existing script that is in the path of script to be entered.Alternatively, the user can select a mode to enter script without havingto shift arm position. In other words, the user can continually write ona single physical line of the input device while the software keepstrack of and provides new (blank) logical line spaces.

The invention also enables the user to perform simple page layoutoperations in order to intersperse free-form drawing areas (non-ruledblocks of lines) with text areas (ruled blocks of lines) on a documentpage. The processor of the invention further allows graphics images tobe drawn and interspersed within line spaces among script/ASCII text.These images can "word wrap" along with the text in which they areimbedded.

The script/text processor's feature set disclosed herein is tailored forthe typical user. If an editing or script-entry error occurs, the usersimply corrects it, using other editing functions. One can providefunctionality desired by the less common user by adding self-teachingfeatures to the algorithms. Typical users of the invention would bepeople who want to quickly jot down notes with/without drawings; peoplewho need to make drawings along with descriptive text, e.g., engineers,lab workers, coaches; people who want to quickly record/revise ideas asdiscussions progress, e.g., students; writers that do not want to leaveany trace of writing that has been revised, e.g., letter writers,confidential communications; and people who desire to represent theirviews of the world in a hierarchical manner through the use of anoutline. The information being represented hierarchically can be script,text and/or drawings, including structured diagrams.

Another class of user is the writer who does not compose documents atthe keyboard (e.g., doctors on rounds, shop-floor supervisors,executives, people who cannot or prefer not to type). Documents willtypically be composed in script and handed off to a secretary fortranslation/typing into ASCII text. The secretary may then download theASCII document into the script/text processor for a round of revision bythe author. Downloaded documents can be read, annotated, and editedbefore being electronically returned to the secretary or publisher.

The foregoing and other objects, features and advantages of theinvention will become more readily apparent from the following detaileddescription of a preferred embodiment of the invention which proceedswith reference to the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a PC with a pen-based script/text entry andediting system according to the invention.

FIG. 2 is a block diagram of a free-standing pen-based computer systemincorporating the present invention.

FIG. 3 is a state diagram of various events in the operation of theinvention and FIGS. 3A-3F are flow charts of the process substepsresponsive to each of the events of FIG. 3.

FIGS. 4 and 4A-4H are diagrams of gestures used in the invention forediting script and/or text in the editing mode of FIG. 3, and FIG. 4Ishows the preferred set of gestures used in editing and select modes ofgesture control.

FIG. 5A is a diagram illustrating word-separation concepts used in wordwrapping and FIG. 5B is a diagram showing wrap-gap management in theinvention.

FIGS. 6A-6D are diagrams of the script bit-mapping and compressionprocess.

FIG. 7 is a diagram of a typical document display formatted, accordingto the invention and FIGS. 7A-7U are a sequential series of displayscreens showing a script/text document in the system of FIG. 1 asvarious editing functions are performed.

FIG. 8 is a preferred set of command icons and corresponding functionsused in the present invention.

FIG. 9 is a diagram of a method for encoding script and ASCII text ininternal document format according to the invention.

FIG. 10 is a diagram showing a method of text entry in a pen-basedcomputer system.

FIG. 11A-11E are diagrams illustrating the opening, use, and closing ofmoving space.

DETAILED DESCRIPTION

The following description outlines various hardware and softwareenvironments in which the handwritten script and text (e.g., ASCII)processing software of the invention can be implemented. Next describedin subsequent sections are script/text document and page attributes; theevent-driven process used to implement the method word boundaries andwrapping; beginning-of-line designation; processing of ASCII text;interword space management including break point gap analysis, wordwrapping and wrap-gap manipulation; gesture-based editing; conversion ofstrokes to internal stroke format using an efficient script compressiontechnique and representation of ASCII text in internal stroke format,concluding with an example showing a series of editing processes in anoperational pen-based system according to the invention.

Preferred Hardware Environment

FIG. 1 shows a personal computer (PC) 10 having a graphics input devicesuch as a digitizer 12 that is sensitive to a pen or stylus 14 that canbe used to enter script and editing gestures in a document containingscript and/or ASCII text. This computer has a document display screen 16distinct from its pen sensitive digitizer and can include a printer 18or other output device. FIGS. 7 and 7A-7U show document pages from sucha screen as used in the invention.

The graphics input device is preferably but need not be capable ofentering script. It can be merely a pointing device, e.g., a mouse,light pen, touch pad, keyboard cursor, etc., used to edit existingdocuments containing script/ASCII or to create and edit documents usinga keyboard (not shown) for text entry. The presently preferred inputdevice is a digitizer which is responsive both to stylus contact (pendown), position and stylus proximity (pen close--e.g., 1/2" or 1 cm.)such as the WACOM 50-510C digitizer and stylus, U.S. Pat. No. 4,786,765.Alternatively, a digitizer and stylus that is contact, position andpressure sensitive could be used, such as made by Summagraphics Corp.,U.S. Pat. No. 4,786,764. A further alternative input device isresponsive to stylus angle as well as being contact, position andpressure sensitive. In a computer having a keyboard with cursor keys,key action can be mapped to the editing gesture control functions,allowing documents containing script and/or ASCII to be edited from thekeyboard as well as the graphics input device. Documents can be createdusing the keyboard for text entry and edited in script form.

FIG. 2 shows a notebook sized computer 20 with integrated display anddigitizer 2 that is responsive to a pen (stylus) 24, and an outputdevice shown in this instance as a FAX/Modem 26.

Other hardware that can be used include:

A FAX machine with integrated display and digitizer that is connected toa computer and responsive to a pen (stylus);

A Whiteboard/Blackboard type of display having an integrated digitizerthat is responsive to a pen (stylus) and connected to a computer; or

A pen sensitive digitizer and light transmissive display panel (e.g.,LCD) connected to a computer and positioned as an overlay on an overheadprojector. A similar device is marketed that allows pen-type input butdrives the overhead projector rather than being light transmissive; thistoo could employ the present invention.

Preferred Software Environment

The presently preferred software for carrying out the method of theinvention is shown in FIGS. 3-3F and further described below.

This software can be implemented in a number of alternative softwareenvironments. The invention has been implemented in C language on a386-based personal computer running GO Corporation's PenPoint OperatingSystem, and is transferrable to Microsoft's Pen Windows OperatingSystem.

It can also be implemented on any other operating system that canprovide information on pen (stylus) activity, including an operatingsystem such as MSDOS or OS/2, that provides graphics input device and/orkeyboard feedback. The invention can also be used in a computer that hasno operating system but has the ability to access and control thehardware components attached to a computer system via software commands.This can include sensing stylus position on a digitizer, capturingkeystrokes on a keyboard, or outputting graphic images onto a display.

Script/Text Document and Page Attributes

FIG. 7 shows a document display screen 30. A script/text document 32 inaccordance with the invention comprises multiple pages for entry andediting of script/ASCII text with or without embedded drawings, as shownin FIGS. 7A-7U. The user is able to "screen" page, "paper" page orscroll through the document. The user can also write a page numberwithin a translation area to directly reference that page. A "Find" menuoption can search the document for a specific ASCII string (in thefuture "fuzzy fit" script string searches can also be provided).

A script/text document could also be a single page, with margin-lessinput or lined area comprising one or more lines. This "document" mightserve as a component in a larger application.

As shown in FIG. 7, a page of document 32 typically contains a group ofruled lines 34 defining line spaces 39 that allow script/ASCII textentry and editing, above each line. The lines each have beginning andending points 36, 38 defining line length. The lines as a group define alined area. Preferably visible to the user, the processor can include anoption to hide the lines while retaining their attributes.

Portions of the page that are not ruled are considered to be margin ordrawing areas, although it is permissible to imbed drawings within linesof text. The drawing areas include left and right margins 40, 42 and topand bottom margins 44, 46. The top and bottom margins as shown includetwo unruled line spaces each. The user can change the size and positionof the text and drawing areas including the number of line spaces, ifany, used as top and bottom margins.

Within the text (ruled) areas, word wrapping can occur. A user is freeto write or draw anywhere on a page but should keep in mind that largedrawings (i.e., drawings with a height of two or more lines) in thelined area might be broken up during word wrap, and text in a drawingarea cannot word wrap. Pages are separated by non-hard page breaks 48which allow word wrapping between adjoining pages.

The line spaces and their respective contents are maintained as units ina tree-type data structure that allows traversal to extract the unitsserially for presentation in the document display. Other data structurescould be used but this one is advantageous for supporting outlining.

Automatic control code insertion allows the user to write on ascript/text document as would normally be done on a piece of paper, withthe processor taking care of the line-by-line formatting. This isaccomplished by the processor watching where, when, and how the userplaces his strokes. For instance, if a user writes on a line, skips aline, and then writes on the following line, then it can be assumed thatthe user wants the blank (skipped) line to remain blank. Editingfeatures such as word wrapping would not overwrite the blank line. Thisfeature and its use with static (scanned/FAXED) images is described inmore detail in the section entitled Beginning of Line Designation.

A menu or gesture-selectable script processing feature, positioncontrol, allows the user to continuously write within a certain area onthe display without having to perform "explicit" actions (e.g.,scrolling) to position the input area. The input area will be positionedfor the user by automatic scrolling. (Note that scrolling up (manual orautomatic) at the end of the document causes blank lines to be appendedto the document). Automatic scrolling will typically be triggered by penout of proximity.

Some varieties of the feature are, once the boundaries of auser-specified screen area have been exceeded, pen out of proximity willcause the document to scroll so that the input area again resides withinthe screen area boundaries. Another version has pen out of proximitywithin the document causing scrolling equivalent to the number of linesused (blank lines written on) since the last pen out of proximity. Ananalogous gesture can also be provided that performs the same functionas pen out of proximity, for use with graphic input devices that are notproximity-sensitive.

A preferred set of basic editing gestures and their functions aredescribed in the section below entitled Gesture Based Editing anddemonstrated in an operational processor in Example 3 and FIGS. 7A-7U.The next section describes the processor software diagrammed in FIGS. 3and 3A through 3F.

Description of Event-Driven Process

FIG. 3 shows the main process of the present invention. The various penor stylus digitizer events that drive the application are described asfollows:

Pen Down: Event is generated when the stylus contacts the digitizingsurface.

Pen Up: Event is generated when the stylus loses contact with thedigitizing surface.

Pen Move: Event is generated when the stylus moves while in contact withthe digitizing surface.

Pen Stroke: Event is generated when user completes a stroke with thestylus along the digitizing surface.

Pen Out of Proximity: Event generated when the stylus, already out ofcontact with the digitizing surface, leaves proximity (i.e., the sensingrange of the digitizer). The stylus is in proximity when it is within adistance approximately one half inch of the digitizing surface. Thisdistance can be varied.

FIGS. 3A-3E flow chart the process substeps initiated by each event. Atany time during the process of FIG. 3, the timer subprocess of FIG. 3Fcan assert an interrupt to initiate a gesture command sequence.

Referring to FIG. 3A, the Pen Down event causes recordal of the pen downlocation and starts a timer for detecting a gesture prompt. The timeridentity is recorded and, referring to FIG. 3F, if this timer times outbefore another timer is set then the system generates a gesture promptat the pen down location. Then the subprocess returns to the mainprocess and awaits the next event.

In the case of a Pen Up event, the subprocess of FIG. 3B sets the latesttimer to zero (which invalidates the gesture timing process of FIG. 3F),records the pen up location, and returns to the main process.

The Pen Moved event initiates the subprocess of FIG. 3C, to determinewhether line space needs to be opened and, if so, to open space, wrapdownstream line space contents to subsequent lines, update the display,and return to the main process. If the pen has moved by more than apredetermined amount (i.e., changed location), the latest timer is setto zero, which invalidates the gesture prompt timer of FIG. 3F.

The Pen Stroke event initiates the subprocess of FIG. 3D. Thissubprocess causes the pen stroke to be interpreted either case a writingstroke, in which as script strokes are processed and displayed (ink isdribbled), or as a gesture, which in turn is interpreted and acorresponding command function is executed, as described below. Eachbranch in the subprocess concludes by updating the display and returningto the main process.

The Pen Out of Proximity event causes the subprocess of FIG. 3E to resetthe latest timer to zero and then initiates a scrolling function.

Further details of the software implementation will be understood andprogrammable by persons skilled in programming pen-based systems byreference to the procedures diagrammed in FIGS. 3A-3F. The basic editinggestures are shown in FIGS. 4A-4H and their respective functions aredescribed below. It will also be appreciated that these procedures canbe varied, for example, to add gestures (see FIGS. 3D(b) and 3D(c), orto substitute different forms of events suited to different kinds ofpen-based input devices (e.g., Pen Vertical instead of Pen Out ofProximity).

Beginning of Line Designation

Text, script and script/text documents consist of words, physical lines(where words reside), and blank space. The script/text processorcurrently formats all documents using only Beginning Of Line (BOL)markers. BOL markers are inserted automatically whenever the user'sscript entry implies that a new line of script has been started.

What the BO marker does is protect the text and/or script on the linewhere it resides from being shifted to a new horizontal position duringword wrap reflow of the document. That is, words pushed from a precedingline will not wrap onto the beginning of the line containing a BOLmarker. Instead, the entire latter line is pushed down and a whole newline is opened to receive the pushed-down words from the preceding line.In the case of blank lines, BOL markers are used to assure that the linewill remain blank during word wrap reflow. Ordinarily, these markers arenot visible but optionally may be displayed.

A user can also explicitly insert a BOL marker (see FIG. 4C andassociated description). Unlike a carriage-return/line-feed symbol whichthe user must explicitly insert in conventional ASCII text processing,however, the BOL marker is ordinarily inferred from text position and isautomatically input. This is important for a pen-based system so thatthe handwriting user need not insert control characters.

How words are arranged on lines and how lines of script are arranged ona page by a user has significant meaning. Without factoring in when andhow the following words came to be in their current position, we candetermine whether to insert a BOL marker at the beginning of each lineof text (or script) data in the following example document:

    ______________________________________                                        Line                                                                          ______________________________________                                        1         This is an example document which has a                             2         total of nine lines.                                                4         A list can help one remember:                                       5                                                                             do this                                                                       6                                                                             then this                                                                     7                                                                             8             Signed,                                                         9                Signature                                                    ______________________________________                                    

Line 1: Insert BOL marker because this is the first line in thedocument.

Line 2: Do not insert BOL marker because no space was available at theend of the preceding line for the first word on this line.

Lines 3,7: Insert BOL marker because lines are blank and are followed bynon-blank lines.

Line 4: Insert BOL marker because this is the first line following ablank line.

Lines 5,6: Insert BOL marker because preceding line does not containtext (has blank space) for a statistically significant distance prior tothe right margin.

Lines 8,9: Insert BOL marker because text is substantially indented.

The example document could have been a scanned or FAXed document thatwas converted to script/text processor document format before being"statically" formatted by the processor. It could have also been adocument that was dynamically formatted as the user entered scriptand/or text. Situations like the following might then have occurred:Line 2, having been left blank while the text on the following lines wasentered, had a BOL marker inserted. The user then decided to enter texton line 2. Having done so, line 2 would have its BOL marker removed forthe same reason that a BOL marker was not inserted in the first example.Now if the user wanted a BOL marker to be inserted at the beginning ofline 2, the insert BOL gesture could be used at the end of line 1 (seeFIG. 4C). Because this would be an explicit insertion of the BOL marker,automatic line formatting would not remove the BOL marker--the userwould have the option of removing it with the delete space/BOL markergesture (see FIG. 4B)

Any time the user touches the pen to the document portion of the screen,ink will be available for writing/drawing. If a character/wordtranslation process is enabled and the user writes in the text area,translation of script to ASCII text will occur in the background. Thetranslated characters will replace the script and can be edited in thesame way as the script. Editing features for script/ASCII text anddrawings are available to the user through gestures, icons, and menuchoices.

Text Processing in Script/Text Document

For illustration, let us assume that user wants to write a mixedscript/ASCII document using the processor of the invention. Startingwith a blank piece of "paper," as shown in FIG. 7, a user will typicallyconstruct a script/ASCII document by entering the script text (cursiveor printed) and having it translated to ASCII in the background. Anotherway is if the user manually edits a pre-existing ASCII document byinsertion of script. Edits can be made to either the script or ASCIItext as further described below.

In order to be able to perform word-oriented editing operations on bothscript and ASCII text with a single gesture set, the script and ASCIIportions of a document both need to be represented as a series of words.In both handwritten and printed ASCII documents, words are separated bya larger amount of space than that which separates the characters withina word. The larger amount of space between words is the basis upon whichthe processor decides where a word begins.

The script/text processor could decide how much space to look forbetween script words by watching how the user spaces words as writingoccurs, basically learning what type of spacing to expect, but a simplerapproach is used effectively in the present invention.

The present method provides the user with a default word spacing value(which can be determined by watching the user write a line (e.g., thefirst line) of text.) This value specifies a default break point gap(BPG) or spacing which defines a space between words of script, andthereby defines "words," per se. Unlike the space in typed text (e.g.,produced by an ASCII space-bar character) the break point gap is definedby the physical word spacing in script, which is variable in length. Theprocessor enables the user to adjust the word spacing value (i.e., theprocessor's BPG) to his personal script word spacing (i.e., to theuser's own BPG).

The processor orders strokes/ASCII character images within a line bytheir left-most point (pixel) position. Accordingly, the word spacingvalue (BPG) specifies the amount of space that must exist between theleft-most point (pixel) of a stroke or ASCII character image and theright-most point of all the preceding strokes and/or ASCII characterimages on the line in order for the stroke/ASCII character beingexamined to be recognized as the first stroke/ASCII character of a word(see example in FIG. 5A).

The user can increase this value if it is found that partial words arebeing recognized as words. Or the user can decrease this value if it isfound that multiple words are being recognized as a single word. Thisapproach has been found to be highly reliable once the user finds a goodpersonal word spacing value. Keep in mind that the word spacing value isused for recognizing where a word begins (and thus where the precedingword must have ended). The spacing that the user gives words whilewriting is maintained although inter-word space compaction or expansioncould be applied to position words on a line.

Word spacing within ASCII text is far more consistent than withinscript. The word spacing is usually different from that of script,depending upon differences in the relative size of the script and ASCIItext. The processor maintains a separate word spacing value for ASCIItext. This value is essentially determined by looking at the ASCIIcharacter size values resulting from the font+point size selection. Theuse of multiple font+point sizes in a document will require that a wordspacing value exist for each font plus point size combination. Within astring of text of a particular font plus point size, only theappropriate word spacing value will be used to determine wordboundaries. As script is translated into ASCII, the processor assigns aword spacing that is appropriate for the font plus point size. This doesnot restrict the user from inserting additional space between words byusing the space insertion gesture, nor does it restrict the user fromremoving space between words by using the space deletion (erasure)gesture. Space inserted between script or ASCII words can only help theword recognition process, whereas space deletion can hinder the process.

When an ASCII document is downloaded into the processor, it must beconverted to the processor's internal document format in order for it tobe manipulated using the edit gestures. Paragraph boundaries are easilydetermined in ASCII documents because they are typically demarcated byexplicitly-used carriage-return line-feed characters. Word boundariesare also easily determined in ASCII documents because the ASCII spacecharacter is used to separate words.

When a scanned or FAX document is downloaded into the processor, it mustalso be converted to the processor's internal document format. Thetechniques used to determine word boundaries described above are alsoused to determine word boundaries once line boundaries have beenrecognized within the input document.

EXAMPLE 1

Assuming the following BPG values: script word spacing value: 9 units;ASCII word spacing value: 6 units. FIG. 5A shows a line of cursive andprinted script and ASCII text created by the user in which the processorrecognizes word boundaries using the following criteria:

(A) First stroke/ASCII character image is always recognized as thebeginning of a word.

(B) 10 units exist between left-most point of "P" and right-most pointof all preceding strokes/ASCII character images on the line. Since 10 isgreater than or equal to the script word spacing value, "P" isrecognized as the beginning of a word.

(C) Not enough blank space for "N" to be recognized as the first letterin a word.

(D) Whether script or ASCII word spacing value is used for comparisondepends on the ratio of the ASCII character image dimensions whencompared to the script dimensions.

(E) 6 units exist between left-most point of the ASCII character image"t" and the right-most point of all preceding strokes/ASCII characterimages on the line. Since 6 is greater than or equal to the ASCII wordspacing value, "t" is recognized as the beginning of a word. Note:Proportionally spaced ASCII characters would require a word spacingvalue specific to each adjacent ASCII character pair.

The next three sections describe a preferred implementation of thisaspect of the invention in further detail.

Gesture-Based Editing

A context-sensitive gesture set is provided for editing text anddrawings. The user is free to write or draw anywhere on a page, butshould keep in mind that large drawings in a text (ruled) area might bebroken up during word wrap and text in a drawing area cannot word wrap.

Gestures are pen movements used to tell the processor control program todo something. This invention uses a two-part gesture. The first partinitiates gesture control; the second part is the gesture itself. Theprocessor allows the user to perform a pen action within the document toindicate that a control gesture is going to be made that should not beinterpreted as an additional text/drawing stroke. The pen actionstimulates feedback by causing display of a gesture prompt. The threeprimary ways (although there are many more) to get a gesture prompt are:(1) touch the tip of the pen (stylus) to the digitizer surface and holdit in this position for a split second; (2) tap the digitizer surfacewith the tip of the pen and then touch the tip of the pen to thedigitizer surface at approximately the same position as the tap; or (3)in a system in which pen angle is sensed, a particular pen position(e.g., vertical) can be used to initiate a gesture prompt. Note that aspecific pen action need not be tied to a specific gesture prompt. Theuser can be provided with a way of mapping pen actions to gestureprompts (and thus gesture classes). This would, for instance, allow theuser to use the most efficient and/or comfortable pen actions to performthe gesturing tasks currently at hand. The user could then remap the penactions to a different gesture class and proceed to use those same penactions to efficiently and/or comfortably do something else.

When one of the above actions occurs, a visible gesture prompt symbolwill be presented to the user. The gesture prompt symbol can take a formassociated with the class of gestures that it represents. For action (1)above, the preferred prompt is a filled circle 50 at the pen downlocation as shown in FIGS. 4-4I. Action (2) can be used to get aselection gesture prompt in the form of a vertical bar 52 (FIG. 4I). So,in addition to being context sensitive, gestures are "prompt sensitive."The particular shape of the prompt displayed to the user can be varied(see FIG. 4I) and it is not essential to display a prompt symbolalthough very much preferred.

After seeing the prompt, the user moves the pen in a selected direction51 (FIG. 4) to invoke a desired function. For the prompts and associatedgestures described within this patent application, the tip of the pen isheld to the digitizer surface beginning with the prompt and continuingthrough the gesture. For other prompts and gesture classes, the pen maynot need to remain in contact with the digitizer surface. For instance,an "object drawing" prompt could be followed by the entry of multipleline segments, with the gesture recognition algorithm examining eachline segment until a particular geometric shape (e.g., square, triangle,circle, etc.) was recognized. At that point in time, the user would bepresented with a high quality representation of the recognized shape andthe gesture would be complete (unless the object drawing prompt was usedto enter a mode (drawing mode) that must be explicitly exited usinganother gesture).

For many gestures, gesture recognition can occur before the gesture iscompletely drawn. The gestures described in this application were chosenfor many reasons, one being that they can be recognized as they arebeing made. This allows gesture feedback to be provided to the user atthe earliest possible time. When the user makes a gesture, immediatefeedback that corresponds to the type of gesture being made will beprovided.

For example, a selection gesture can cause the selected line space andstrokes/words to be highlighted in some way, such as by drawing atransitory line that follows the gesture as shown in FIG. 7D, or byinverse video or bolding the selected line space and script or text.With sufficient computing speed, the selected command function can beexecuted as the gesture is being made. For instance, a line insertiongesture could cause blank lines to be inserted and displayed as the usermakes the gesture. This sort of feedback is highly desired by the user.

Following is a description of the preferred gesture set as shown inFIGS. 4A-4H and the control and edit functions for each gesture.

Insert Space Gesture 54 (FIG. 4A)

This gesture inserts (opens up) an amount of space on the gesture lineequivalent to the length of the gesture stroke. Words pushed off the endof the line wrap to the next line.

Delete Space Gesture 56 (FIG. 4B)

This gesture deletes (collapse) space/strokes underneath the gesturestroke. Words from following lines may wrap back to the gesture line ifit is permissible to remove words from the following lines (i.e., nointervening BOL marker). If this gesture follows all strokes on a line,words will be allowed to wrap back to the gesture line from thefollowing line even if they previously were disabled from doing so by aBeginning of Line marker.

Insert Beginning of Line (BOL) Marker Gesture 58 (FIG. 4C)

All strokes (words) following this gesture are wrapped forward to thenext line. No words from preceding lines will be allowed to wrap ontothis "protected" line unless the Beginning of Line marker is removed.The number of markers inserted depends on the distance of the gesturestroke. Multiple BOL markers will appear to the user as blank lines.

Delete Line Contents Gesture 60 (FIG. 4D)

This gesture deletes the text (ruled) area contents of each line touchedby the gesture stroke.

Mark Block Gesture 62 (FIG. 4E)

Two separate gestures are required after the gesture prompt to mark ablock of text. The first gesture marks the beginning/end of the blockand the second gesture marks the end/beginning of the block. The markblock gesture line must stay within the confines of the ruled line lestit be recognized as an Insert BOL marker gesture. Ink dribbling, paging,scrolling, etc. can occur between the beginning and end mark gestures.

Insert/Collapse Moving Space Gesture (FIG. 4F)

The insert moving space gesture consists of lifting the pen out ofcontact with the digitizer surface without moving it laterally, afterthe gesture prompt. This gesture is used to open up an indefinite ormoving amount of space within a line of script or text so the user caninsert additional script or text. About 1.5 inches (6 cm.) of space willbe opened immediately to the right of the pen down position initiallyupon recognition of the gesture. After the space opens, the user lowersthe pen and begins writing. As the user writes, additional space willautomatically be provided in order to accommodate continuing strokes.This method can be called "auto-insertion." Any words pushed off the endof the initial pen-down line by the auto-insertion will be wrapped tothe following line. Repeating this gesture (i.e., prompt plus lift pen)collapses the moving space.

Note that actions resulting from the foregoing gestures, when located inthe lined area of the document display, will in no way affect drawingsin the unlined drawing areas surrounding or adjoining thegesture-modified text. The gesture set is context-sensitive, however, sothat the same gesture can be used in the unlined areas to perform eitherdifferent editing functions or similar functions only in the drawingarea, i.e., without affecting contents of adjoining lined area.

Line Insertion Gesture (see FIG. 7Q)

The Line Insertion Gesture is like the Insert BOL gesture 58 (FIG. 4C)but is located in the unlined margin alongside a line. A whole line(text area+drawing area) or multiple lines will be inserted in the linedarea laterally adjoining the gesture location shifting all lines belowit downward within the document. This will cause the last line on eachaffected document page to be shifted over the bottom and top margins (ifany) to the first line of the next document page. The inserted linetakes on the characteristics (ruled area margins, etc.) of theline/ruler that precedes it. Multiple lines can be inserted by extendingthe distance that the gesture covers.

Line Deletion Gesture (see FIG. 7S)

This gesture is like gesture 60 (FIG. 4D) but performed in the margin. Awhole line will be deleted from the document, shifting all lines belowit upward within the document. This will cause the first line on eachsucceeding document page to be shifted up over the top and bottommargins (if any) to the last line on the preceding document page.Multiple lines can be deleted by extending the distance that the gesturestroke covers. This gesture can also be used to delete the contents of atop/bottom margin line, although the margin line itself will not bedeleted. The gesture can be used to delete a ruler, causing the linesfollowing the deleted ruler to be formatted according to the rulerpreceding the deleted ruler.

Stretching Box Gesture 64 (FIG. 4G)

The Stretching Box Select gesture (which might also or alternatively berepresented by an icon) selects all drawing area strokestouched/enclosed by the rectangular area. Cannot cross into text area.

Rope Select Gesture 66 (FIG. 4H)

The Rope Select gesture (might also be represented by icon) selects alldrawing area strokes touched/enclosed by roped area.

Prompt-Specific Gesture Sets

Multiple unique gesture prompts allow for the classification ofgestures. Each specific gesture motion can be associated with one ormore prompts (pen actions). In FIG. 4I, two unique prompt images areshown, each with a set of gesture pen motions. Note that the first fivegestures in each set is unique in function although the gestures areidentical motions. The last three gestures in each set are similar inboth motion and function.

Another interesting aspect of the gesture set shown in FIG. 4I is that,with the exception of Pen Up and Mark Block, all of the gesture motionscan be recognized as specific gestures (given the context in which theyare currently supported) even before the gesture is completed! Thisallows dynamic feedback to be provided to the user as the user performsthe gesture (e.g., showing increasing amounts of whitespace and wordwrapping as the user inserts space). The current implementation of thesoftware waits for the user to complete gestures before acting uponthem. Future versions will utilize multi-tasking to provide dynamicfeedback that is highly responsive to the pen.

Selected Strokes

A variety of functions can be applied to selected strokes in text ordrawing area. These functions are available through menu selection:delete, cut, copy, paste, highlight (bold, outline, etc.), translate(from script into ASCII), evaluate (math expressions), etc. In addition,selected strokes can be dragged by touching the pen to the selectedstrokes and dragging. Strokes can be selected by invoking the I-beamgesture prompt 52 (FIG. I) and dragging it through the stroke(s) to beselected.

Additional editing tools can be provided and represented by suitableicons. All tools are picked up, used one or more times, and thenreturned to their original places. A preferred set of tools and examplesof corresponding icons are shown in FIG. 8.

Ruler 70

The user picks up the ruler icon in order to insert a ruler. A rulerwill be inserted at the pen down position within the document.

Highlight 72

The highlight marker is used to highlight strokes. The highlight remainson the strokes until it is explicitly removed by the user through repeat(inverse) highlighting or SELECT, choose new highlight. Multiplehighlight markers or a single "multicolored" highlight marker may existto accommodate different highlighting needs.

Pointing Finger 74

The pointing finger is used to select text. It can be used in place ofthe drag select gesture if desired. It is different from the drag selectgesture in that it allows the user to select more than one piece oftext.

Eraser 76

The eraser erases pixels within text or drawing areas without collapsingblank space. The eraser can come in different sizes to erase pixelswaths of different widths.

Rubberband Line 78

The rubberband line is provided so that the user can draw straight lineswithin the text or drawing area without the use of a template orstraightedge.

Circle

The circle allows the user to draw variable sized circles within thetext or drawing area without the use of a template.

Open Drawing Space Left 82, Full-Width 84 and Right 86

These icons are invoked to change line lengths to increase the availableunlined drawing space in an adjoining margin, or to extend the drawingspace all the way across the page.

Stroke Eraser 88

The stroke eraser will erase only the pixels of strokes, not affectingany ASCII text. This is quite useful when annotating documents thatexist primarily in an ASCII text form.

Conversion of Strokes to Internal Stroke Format

Following is a description, with reference to FIGS. 6A-6D, of howstrokes go from being input glyphs to residing within the softwaresystem as meaningful data in accordance with another aspect.

For simplicity, the following description assumes that lines are storedat screen (raster) resolution. As shown in FIG. 6A, the document existsin a window (a bit-mapped display area having its origin in the lowerleft corner) having a series of logical lines, the first line beingnumbered 1 and succeeding lines having increasing line numbers (throughline N). The document is displayed with lower document line numbers(e.g., lines 4, 5, 6) appearing at the top of the window and documentline numbers increasing as document lines are displayed toward thebottom of the window (e.g., line N+3). At any point in time the windowrepresents a viewport onto a certain number of document lines. The exactlocation of the viewport onto the document is maintained by keepingtrack of the first (topmost) document line (e.g., line 4) that will beviewable in the window.

When a stroke is stored into the document, the document line into whichthe stroke will be rooted must be determined. The process requires a fewsteps:

The first step is to determine which window line the stroke belongs to.A number of methods exist for mapping a stroke to a certain window line(e.g., center of gravity) but for purposes of simplicity (and because itworks pretty well) let us assume that a stroke belongs to the line inwhich the pen tip first touched the digitizer. The window line is thendetermined using the following equation:

    WLN=((FRR-PDYV)/RRPL)+1

in which:

WLN=Window Line Number;

FRR=First Raster Row;

PDYV=Pen Down Y Value; and

RRPL=Raster Rows Per Line.

Now that the window line number has been determined, the document linethat the stroke belongs to can be determined by the following equation:

    DL=(TDL+WL)-1

in which:

DL=Document Line;

TDL=Topmost Document Line; and

WL=Window Line

Once the document line is determined, the document line needs to beretrieved from the document line database.

With the document line in hand, the relative position of the strokewithin the line must be determined. Due to the nature of the strokecompression method used to store strokes (it stores points within astroke relative to the first point of the stroke), only the first pointof a stroke needs to be assigned a position within the document line.The position will be relative to the line's left margin for the X-axisand relative to the bottom-most "raster" row owned by the document linefor the Y-axis. This position can be identified by relative coordinatesX' and Y'. The actual X and Y values used to anchor the stroke within adocument line are determined using the following equations:

    X: window X coordinate for first point in stroke

    Y: window Y coordinate for first point in stroke

X'=X-left margin window X coordinate for the document line

Y'=Y-((FRR+1)-(WL*RPL))

in which:

FRR=First Raster Row;

WL=Window Line; and

RRPL=Raster Rows Per Line

Now that the coordinates used to anchor a stroke within a document linehave been determined, the next step is to compress the remaining pointsof the stroke. Any compression algorithm used must retain thepoint-to-point directional information inherent in strokes if thosestrokes are to be translated into ASCII text or used to characterizehandwriting at some point in the future.

The basic assumption behind the processor compression algorithm is thatstrokes have momentum--a stroke is more likely to continue moving in aspecific direction than it is likely to move in a dramatically differentdirection. This allows compression of a stroke by representing pointincrements within the stroke with predefined values that reveal anychange in direction. For instance, the binary value 1 would mean:continue forward one point in the current direction. The binary value 00would mean: move forward and to the left of the current direction by onepoint, causing the current direction to be redefined by the newdirection. The binary value 01 would mean: move forward and to the rightof the current direction by one point, causing the current direction tobe redefined by the new direction. Visually it might look like FIG. 6B.

EXAMPLE 1

The arrows in FIG. 6B represent the current direction after the point ateach arrow position has been encoded. The initial direction fromstarting point "x" is encoded per the binary values shown in FIG. 6C.The actual encoding of the circle shown would be a concatenation of thefollowing binary directional data:

    ______________________________________                                        01011   Point count in stroke less 1 (Note: This is the                               binary length of the stroke; it can be up to,                                 e.g., 32 data points)                                                 000     Direction from starting point "x" to point 2                                  (Note: the starting point is recorded as an X-Y                               coordinate. This is the "root" point of the                                   stroke. This direction is the current direction                               at point 2.)                                                          01      Direction change needed to get to point 3                                     (Note: 01 shows a change to the right; 00 would                               be to left.)                                                          1       Continue in current direction to get to point 4                       01      Direction change needed to get to point 5                             01      Direction change needed to get to point 6                                     Continue in current direction to get to point 7                       01      Direction change needed to get to point 8                             01      Direction change needed to get to point 9                             1       Continue in current direction to get to point 10                      01      Direction change needed to get to point 11                            01      Direction change needed to get to point 12                            25      bits                                                                  ______________________________________                                    

This algorithm requires that all points in a stroke be adjacent. Therecan be no gaps or adjacent points having the same coordinates (duplicatepoints). In order to assure that there are no gaps, a line drawingalgorithm is employed to fill any gaps in a stroke (typically due tomoving the pen too fast) with a straight line before any attempt is madeto compress the stroke. To remove duplicate points, which typicallyresult from digitizing at high resolution and translating to a lowerresolution, any duplicate points exceeding one are discarded at eachposition.

In order for this type of compression to be most efficient, thedigitized strokes need to be smoothed. For instance, extraneous points,which result from digitizing at high resolution and translating to alower resolution, need to be removed before the compression algorithm isapplied. These extraneous points can be detected by searching througheach stroke for formations that give the appearance of an "L" (two linesmeeting at right angles. This search uses the matrix shown in FIG. 6D.

An "L" formation in FIG. 6D would be any series of points that fall intoa 1, 2, 3 sequence. As a stroke is compressed, each point of the stroke(actually each point that is retained after the "L" formation lookahead)takes its turn in the "1" position. If the following 2 points make an"L" formation, then one of them must be discarded. The point to bediscarded is determined by examining the position of a 3rd pointfollowing the point in the "1" position. This third point is not shownin FIG. 6D but could appear anywhere within the matrix (except in the"3" position because duplicate points have been removed) or asurrounding ring of points around the matrix. Of the points in the "2"and "3" positions, the one farthest from the third point (i.e., thepoint requiring the largest change in X and Y coordinate values to reachthe third point) is discarded.

The compression algorithm as described requires that strokes exceeding32 points (only 5 bits in point count) be broken into a series of"ministrokes." It also requires strokes having too radical a change ofdirection for direction change encoding to be broken into ministrokes,as in the case of a script "M." The resulting ministrokes arecompression encoded as described above. Alternatively (or also), thestroke length could be set at 64 points (6 bits) or more for higherresolution digitizers. These encoded ministrokes are then concatenatedto form the whole stroke, the last point of each ministroke being the`start point` of a succeeding ministroke.

A variation on this stroke compression method allows for compression ofstrokes having less momentum (i.e., many closely spaced directionchanges). An expanded set of encoding values is employed:

EXAMPLE 2

    ______________________________________                                        1:     Move forward one point in the current direction                        000:   Move 1 point counterclockwise from the current                                direction and forward. The new direction becomes                              the current direction.                                                 001:   Move 2 points counterclockwise from the current                               direction and forward. The new direction becomes                              the current direction.                                                 010:   Move 1 point clockwise from the current direction                             and forward. The new direction become the current                             direction.                                                             011:   Move 2 points clockwise from the current direction                            and forward. The new direction becomes the                                    current direction.                                                     ______________________________________                                    

After bridging gaps within a stroke, removing duplicate points anddiscarding extraneous "L" pattern points, the circle used in the firstcompression example would be compressed and encoded as follows:

    ______________________________________                                        01011   Point count in stroke less 1                                          000     Direction from starting point to point 2                              010     Change direction to right to get to point 3                           1       Continue in current direction to find point 4                         010     Change direction to right and down to get                                     to point 5                                                            010     Change direction to down to get to point 6                            1       Continue in current direction to get to point 7                       010     Change direction left and down to get to point 8                      010     Change direction to left to get to point 9                            1       Continue in current direction to point 10                             010     Change direction to up and left to                                            get to point 11                                                       010     Change direction to up to get to point 12                             32      bits                                                                  ______________________________________                                    

As can be seen, the first compression method compresses the examplestroke much more than the second compression method. This will notalways be the case. Certain strokes will be compressed more using thesecond method rather than the first, for instance a stroke that variesmore widely in direction than the example stroke. The point is that theprogram can analyze the stroke characteristics before applying a certaincompression method to the entire stroke or a ministroke constituting aportion of the entire stroke.

What have been described are single pass methods for compressingstrokes. A second compression pass can be applied to the compressedstrokes, thus obtaining greater compression at the cost of additionalcompute time. In the examples shown, the repeating patterns ofdirectional change can be compressed, using any of a variety of knownpattern compression techniques. The program would determine whether anyadditional compression passes would be warranted.

Returning to the original task of describing how strokes are processedand stored in the software system, let us review what has been covered:

Mapping a stroke on the screen to a document line;

Determining the line relative coordinates of the stroke within thedocument line; and

Compressing the stroke.

What remains is a description of the approach used to store strokeswithin the document line data structure.

A document line consists of two distinct writing areas--the lined areaand the unlined or margin areas. Within the margin areas, word wrappingis not supported; as such, strokes need merely be appended to a growinglist of strokes associated with the document line. That is, the strokesare ordered by time.

Strokes within the lined area are stored differently due to the wordwrapping nature of the lined area. See the discussion below on BreakPoint Gap Analysis: The Leftmost Positioning Method for details of thestroke ordering and storage.

Representation of ASCII Characters in a Format Compatible with Strokes

Binary encoded characters (e.g. ASCII characters) by definition aregraphically defined elsewhere. There is no need for the processor toduplicate this information by storing it in a compressed stroke orbitmap format within the data structures comprising a line. The piecesof information that the processor needs in order for it to representASCII characters in a format compatible with strokes are:

The ASCII character code;

The position of the ASCII character within the document window;

Font and point size information.

The position of the ASCII character is determined by the processor usingstandard text spacing algorithms for downloaded ASCII text. For ASCIItext that resulted from the translation of script, the processorreplaces the script with ASCII text as the translation takes place. Thistypically results in a shrinkage of the script since the ASCII textcharacters will usually be smaller than the script characters and theuser normally requests that consistent and standard spacing existbetween characters within a word and between words within a sentence.

The position of the ASCII character, its font, and its point size areused to determine the character's starting point (origin), left-mostpoint, and right-most point positions relative to the lined areabeginning point along the left margin. This is the same sort ofinformation that is maintained for strokes, ASCII characters, andbitmapped images Because strokes are ordered by left-most pointposition, ASCII characters can be interleaved with strokes within theprocessor data structures, allowing for the consistent application ofediting functions to the mixed data types. The processor must be awareof the distinction between data types is when it must display the data.The stroke visual data will be derived from the compressed strokes andthe ASCII character image will be extracted from a table addressed byASCII character code.

FIG. 9 shows that an "o" could exist in a pen-based system according tothe invention as a stroke, an ASCII character, or a bitmap. At thesimplest level, data within the system exists as a series of glyphs,each having a starting point (origin), a left-most point position, and aright-most point position. The starting point (origin) is used toposition the glyph within the line space. Since the left-most andright-most point positions are encoded relative to the starting pointposition, they are automatically moved whenever the starting pointposition is moved, i.e., the stroke/character is shifted left/right. Theleft-most and right-most point positions are used to determine thebreakpoints within a line (the word boundaries) as described above. Theonly time that the processor is (and needs to be) aware of the specifictype of glyph (stroke, ASCII, or bitmap) is when it stores the glyph,when it determines word boundaries, and when it displays the glyph. Atthese times, glyph-specific data is required. Note in FIG. 9 that thestarting point is not really glyph-specific even though it varies withglyph type. It still represents the anchor position for all glyphs andamong all glyph types it is the point that moves.

In FIG. 9, all glyph types have the same left-most and right-most pointpositions (1 and 6 respectively). For purposes of determining wordboundaries and word wrapping, these are the important variables.

Break Point Gap Analysis: The Left-most Positioning Method

In both hand printed and typed (or computer processed) documents, wordsare separated by a larger amount of space than that which separatescharacters within a word. The larger amount of spacing between words isthe basis on which the invention determines word breaks, andaccordingly, word wrap.

The invention employs a novel method for determining stroke-characterword breaks. This method is referred to as the Left-most PositioningMethod (LPM). LPM orders stroke images within a given line according totheir left-most point position. Once a text line has been detected, LPMrelies exclusively on a single axis for acquiring stroke positioningdata. Therefore, strokes are ordered left to right in a stroke database.The time order of strokes entered can be maintained by time-stamping thestrokes.

The Break Point Gap (BPG) value is predetermined at the outset of strokeposition data capture. The BPG is calculated as a predetermined twodimensional area of points (a parallelogram such as a rectangle). Forhighly slanted text, a user-modifiable angle for the parallelogram canbe determined from the user's writing.

As stroke data is captured, LPM relies on the BPG value for determininga word break. LPM performs a comparison between the (white space) valueof the space between the right-most point position of the precedingstroke data, and the left-most point position of the current strokedata, with the BPG value. If the white space value is greater than orequal to the BPG value, then the LPM has detected a word break.Accordingly, LPM inserts a break point marker B (see FIG. 5B) at alocation adjacent to the left-most point of the current stroke data.

Word Wrapping: Employing the Break Point Marker

Word wrapping is the process of filling lines of text/script and movingtext that overflows the line space contents automatically to thesucceeding line space. Word wrap is not mandatory until a text/scriptmanipulation event occurs. When the system detects a text/scriptmanipulation event, then word wrapping is invoked.

The word wrapping detection method involves "reflowing" the text/scriptacross line breaks. This is preferably done by comparing locations ofbreak point markers (B in FIG. 5) with line delimiters (beginning andending points 36, 38). If a stroke is detected as crossing the addressof a line delimiter (or margin boundary), a word wrap is required. Towrap, the system parses backward searching for the last break pointmarker. Upon finding said marker, the system moves all text immediatelyfollowing the marker to the succeeding line, and recursively applies thecheck for a margin boundary violation and again wraps the text/scriptuntil all text/script has been reflowed within the lines such that nostrokes violate a margin boundary.

An alternative implementation would function as follows: Stroke datawould continue to be added to the database, while the system comparesthe amount of data captured with the amount of line space allocated. Assoon as stroke data is captured which, if placed on the current line,would exceed the margin boundary, a word wrap would be required. Theactual wrapping would be triggered by some event or action thatindicated the user had finished writing on the line. To wrap, the systemwould employ the recursive process described above.

WrapGap Analysis: The WrapGap Monitoring Method

Another of the many problems addressed by the invention involvesmaintenance of designated space between words. When editing script text,a means is required for adding and/or deleting white space toaccommodate additional stroke data (more handscribed text).

To facilitate managing the white space between words, a variable calledWrapGap is maintained that records the amount of white space between theleft-most point of the first stroke of a word on a line and theright-most point of all strokes composing words on the preceding line,whenever the current line is viewed as an extension of the precedingline (i.e., no intervening BOL). By default, each line is assigned aWrapGap value that is equal to the BPG value. When word wrapping forwardoccurs, the WrapGap value shown graphically in FIG. 5B indicates theamount of space that must exist between the right-most point of thefirst word wrapping to a line and the left-most point of the first wordcurrently on that line. The WrapGap must then be changed to reflect thespacing between the left-most point of the left-most wrapped word on aline and the right-most point of its former neighboring word on thepreceding line. When the user deletes space or strokes, causing words towrap backwards, the WrapGap value indicates the amount of space thatmust exist between the right-most point of the last word on the linewhere words will be wrapped back to and the left-most point of the firstword that will wrap back to that line. The WrapGap must then be changedto reflect the amount of space between the right-most point of the lastword wrapped back to a line, and the left-most point of the newlypositioned first word on the succeeding line (where the words wrappedfrom originally).

Another common case in which this feature is apparent is when changingline lengths (side margin widths). This case is shown in FIG. 5B, inwhich a line of script is shortened in successive steps and thenreturned to its original length. There are two additional cases wherethe WrapGap value can be modified.

Whenever a word wraps, a new WrapGap value for the line is computed. Inthe first case, a word may wrap because a significant amount of space isallocated preceding the word. Subsequently, a new word may be added onthe preceding line within the previously allocated white space.Therefore, the actual (desired) space or gap between the word beginningon the subsequent line and the word on the preceding line, has changed.This value is no longer the original value allocated between the lastright-most point position of a preceding word and the left-most pointposition of the wrapped word. Rather, it should now be the value betweenthe right-most point position of the added word and the left-most pointposition of the wrapped word. In this way, if a margin is subsequentlyincreased, and/or some other editing function forces the wrapped word toreturn to the preceding line, or the added word to wrap onto thesubsequent line, the actual space between the added word and theoriginally wrapped word will be properly maintained because the WrapGapvalue has been updated to reflect the modification. The user will havethe option of disabling this WrapGap adjustment feature.

Another case for WrapGap value modification occurs when the user employsa "delete-space" gesture (refer to the discussion on "Gesture-BasedEditing" below) following all strokes on a line space. With thisgesture, the user causes words from the next line space to wrap back tothe current line space. If there is a "Beginning of Line" (BOL) markeron the next line space, it will be removed. The system then determineswhether the space consumed by the first word on the next line plus thebreak point gap (BPG) value represents an amount of space less than orequal to the open space available at the end of the line where thegesture was made. If so, then the system detects that at least one wordcan be wrapped-back and, therefore, proceeds to reduce the WrapGap forthat word only enough (if at all) to ensure that such word will wrapbackwards (e.g., return to the preceding line space.)

A variation on this method would use the pen-up X-coordinate position ofthe Delete-Space gesture as the target position (or location) to whichthe left-most point of the first wrapped-back word should be "anchored."In such case, the WrapGap value for the first word to be wrapped backcould be ignored. Only the space consumed by the strokes at the firstword would be considered in determining whether the word can be wrappedback. If the word will fit within the space existing between the pen-uplocation and the right margin, the WrapGap value for the first wordeffectively becomes equivalent to the space existing between theright-most point of all strokes on the wrap-back line and the pen-uplocation.

EXAMPLE 3

FIGS. 7A through 7U show a series of screen displays for an operativeexample of the invention as implemented in a computer system arranged asin FIG. 1 with a stylus and contact and proximity-sensitive digitizer asthe graphics input device. The document display is shown on aconventional graphics CRT monitor and the computer is a conventionalIntel 386-based personal computer. The following figures show a basicsubset of the operations that can be performed on a document display inaccordance with the invention. This example shows the interactivemanipulation of printed script, cursive script and small sketches withinthe lined area of the document display, and of drawings and scriptwithin the unlined or drawing areas and margins of the display. Althoughnot shown in this example, ASCII text placed in the lined area will behandled and will behave during manipulation in essentially the samemanner as script, and can be considered as represented in this exampleby the printed script.

FIG. 7A is a view of an initial screen display in which printed andcursive script have been manually entered by writing on the digitizerwith a stylus. The document display 30 itself includes a top displaymargin, bounded by a pair of closely-spaced lines, containing title andcommand or menu lines. All actions in these areas are treated ascommands and do not result in the entry of script. Besides, or insteadof menu titles "edit" and "services," the command line can include icons(not shown). Below the double line is the display document itself, whichis organized in pages.

As shown in FIG. 7 and 7A, the default structure of each page of thedisplay has a series of parallel horizontal lines 34, each havingvertically aligned beginning points 36 and end points 38. The linesthemselves each define line spaces 39 of equal vertical width. Thebeginning and end points of the lines are spaced inward from the sidesof the display to define the lengths of the lines (which can be varied)and width of left and right margins 40, 42 (which are likewisevariable). The first line is spaced three line spaces below the top ofthe document display space defined by the double line. The spacing ofthe first line below the double line is sufficient to provide a singleline space above the first line into which script or text can be enteredand two additional line-space widths to serve as a top margin 44. Abottom margin 46 having a width of two line spaces is also provided. Thetop and bottom margins 44, 46 are treated as unlined space in the samemanner as the left and right margins 40, 42. The top, bottom and leftand right margins define an unlined drawing area which surrounds thelined script area. The margin areas can be slightly shaded to helpdistinguish them from the script lines.

Referring to FIG. 7B, the "insert space" gesture command has beenperformed in the first line of the script, immediately after the printedscript. This was done by placing the cursor between the printed scriptand the first word of the cursive script, holding the stylus momentarilyin one place in contact with the digitizer surface; then moving thestylus tip rightward to an end point spaced inward from the ending pointof the line, and lifting the stylus. This action has opened a length ofline space defined by the length of the gesture in the first line. Thecomputer document display has also responded to this action by pushingthe script to the right of the insert point of the gesture toward theright in the first line, wrapping down into the second line andrightward in each successive line. After completion and execution of theinsert space gesture, the user drew/wrote a large dot with arightward-directed arrow, followed by the words "Insert Space Gesture"in printed script, into the space that had been opened by the gesture.

FIG. 7C shows editing of the text inserted in FIG. 7B. This is done byperforming a "delete space" gesture, commencing after the word "insert"in FIG. 7B and extending leftward to the beginning of the arrow shown inFIG. 7B. This was followed by an "insert space" gesture to reopen spacethat the "delete space" gesture consumed. Then, a leftward-directedarrow was drawn in place of the rightward-directed arrow and the word"delete" was written where "insert" previously appeared.

Operation of the delete space gesture is further illustrated in FIG. 7D.When this gesture, or any gesture is performed, placing and momentarilyholding the stylus in place on the digitizer causes the display to showa filled circle at the pen down location (after "gesture" in line 1).The filled circle serves as a "gesture prompt" to provide feedback tothe user that the input device is now operative in the gesture mode. Assoon as this gesture prompt is displayed, the user then drags the stylusleftward along the line space to be closed. The version of softwareoperated in the present example actually draws a line through the spaceto be closed (and across the text to be deleted). This illustrates theprinciple of the two-part gesture prompt/gesture command structure, butdisplay of the gesture is not essential. Alternatively, the command canbe executed as the gesture is being made, as soon as the gesture'sdirection is determined. After executing the delete space gesture, thesystem closed the line space between the gesture prompt and the endpoint of the gesture, obliterating the text contained in the line spacebetween such points. A variation on the Delete Space gesture has thestrokes following the gesture on the line (if any) being left-justifiedat the pen up position for the gesture. Another variation has thestrokes following the gesture on the line (if any) being left-justifiedat the left-most point position of any deleted strokes (i.e., thefollowing strokes take the place of the deleted strokes). Thesevariations enable easy maintenance of word spacing.

FIG. 7E shows the operation of the "insert BOL marker" gesture and itscorresponding editing function. This editing gesture and function wasperformed after the word "script" in line 1. It has the effect of addinga beginning of line (BOL) marker at the insert location, that is, at thelocation where a gesture prompt appears upon commencement of thegesture, and then moving the affected text to the beginning (leftmargin) of the next line. Actually, all text on the line following thegesture prompt position is wrapped forward to the next line, that linethen being prefixed with a beginning of line (BOL) marker. As the usercontinues to move the stylus downward across additional lines, theaffected text moves with the stylus, leaving BOL-marked blank lines tofill the gap created by moving the text downward within the document.This can be seen by comparing FIGS. 7D and 7E.

FIG. 7F shows the same line, after doing a sketch of the gesture and abrief description of the gesture's function.

FIG. 7G illustrates what will be done to close the added line. As theedited display of FIG. 7G states, the user executes a delete linecontents gesture by placing the stylus on the point of the digitizercorresponding to a point on the second line of the display and, afterreceiving the gesture prompt, moves the stylus upward toward the firstline.

FIG. 7H shows the screen display after execution of the delete linecontents function. The third line of script is moved up into the secondline, obliterating the script contents of the second line, and isfollowed by an upward shift of the contents of each subsequent linespace. This editing function can be used on multiple lines of text.

As mentioned above, the document display preferably includes multiplepages. The pages are not isolated from one another, however, but permitscript to be moved freely back and forth across page break boundaries.This is shown in FIG. 7I. To illustrate the point, thepreviously-entered script has been shifted downward (using the insertblank line function) to the bottom of the first page. Then, an insertmoving space gesture was carried out in the third line of scriptimmediately preceding the word "principles" to cause the last few wordsof script to word wrap off the end of the last line of the first page.In word wrapping, these words were pushed over the bottom margin, pagebreak and top margin onto the first line of page 2 of the documentdisplay.

FIG. 7J shows the effect of entering additional script commencing at thepoint of the insert moving space gesture in the third line of script onpage 1. The user has entered additional printed script, much as onewould do in editing a document. Rather than filling a space of fixedlength, however, using the insert moving space function causes spacecontinually to be added to the lines ahead of the user's entry ofscript. Thus, the user has entered nearly two lines of script, extendingover the page break onto the first line of page 2. Note that a length ofopen line space remains immediately preceding the word "principles,"which space is the moving space defined by this function. Thus, themoving space as well as the text downstream from it is wrapped not onlyaround ends of lines but across page breaks and margins. In doing so,the contents of the margins (none shown) are unaffected.

FIG. 7K shows closure or collapsing of the moving space, accomplished inthe current implementation by attempting any gesture, including anotherinsert moving space gesture.

When a moving space is collapsed, the spacing between the left-mostpoint of the strokes following the moving space and the right-most pointof the added strokes will be the space that existed between the initialstrokes that were separated by the moving space. This means that if thespace is opened within a word the open moving space will be collapsed toa smaller whitespace gap than if the space had been opened betweenwords.

A variation on the moving space concept has the moving space sensitiveto proximity. After moving space has been opened with the Insert MovingSpace gesture, the moving space would collapse on pen-out-of-proximityand reopen on pen-in-proximity. This would allow the user to makemultiple edits using moving space without having to explicitly open andclose the moving space. When the moving space reopens, the position ofthe moving space within the text would reflect the position of thestylus in proximity. In this way the user could move the stylus aroundto preview various insert positions within words or lines. When pen downoccurs, the moving space would shift according to the user's enteredstrokes. The Collapse Moving Space gesture (same as Insert Moving Spacegesture) would end this process.

Another variation on the moving space gesture has the action of movingthe pen to a vertical orientation causing a Moving Space Gesture prompt.The prompt would be an open space that would move with the pen(pen-in-proximity but not touching) as the user previewed moving spaceinsertion positions within text. (The user need not hold the penvertical once the prompt appears.) Pen-down would be the gesture thatactually created a moving space. Until pen-down, insert positions wouldbe previewed at varying degrees of resolution. Fast pen movement wouldpreview insert positions between words and slow pen movement (overwords) would preview insert positions within words. Returning the pen tothe vertical position (after having been not vertical) would cause themoving space to be collapsed. If the pen tip had not been within (over)the moving space when the pen was positioned vertically then a newmoving space would preview at the pen position.

As mentioned above, drawings can also be included in unlined areas ofthe document display and are not affected by editing functions performedon the contents of the lined area. To illustrate this point, FIG. 7Lshows the previously-entered script moved back to the top of page 1. The"services" menu item has been invoked, followed by selection of the"insert ruler" command. FIG. 7L shows use of this command to cause tworulers to be drawn across the document display at about mid-screen. Therulers are shown as black horizontal bands across the document display.The final version of the product will have rulers containing graphicsdepicting the current margin settings. The top ruler is always present(although it may be hidden) and contains margin settings which can beset by the user wider or narrower than the default margins. The lowertwo rulers are placed by the user at locations designated by contactingthe stylus to the digitizer at user-selected points.

Next, referring to FIG. 7M, using the stylus, the user selects a newline length within the area defined vertically between the lower tworulers. In the present software version, the user affirmatively selectsthe line length by drawing a gesture on the ruler from the left orbeginning point of the line to a desired end point of the line. Thisprocedure could be reversed, to define the margin or drawing area widthbetween the rulers. Alternatively, an icon representative of thisfunction could be provided which the user selects and simply draws aline vertically from top to bottom at a desired location along the linesto define the height and width of the lined space (or conversely theunlined space). This approach would automatically insert and positionrulers where the user starts and stops the vertical line.

Reinvoking the "services" menu and selecting "hide rulers," leaves thedocument display of FIG. 7N. To illustrate subsequent points, the userhas drawn a diagram of a pen-based computer in the unlined drawing areaand has labeled the diagram "pen-based computer."

FIG. 70 shows the document display of FIG. 7N as the user makes a deletespace gesture across some of the script in the second line of thedisplay.

FIG. 7P shows the display after execution of the delete space function.This causes the contents of subsequent lines to word wrap or reflowupward to fill in the space occupied by the deleted line space contents.Note that reflow of the line contents has no effect at all on thedrawing and script labeling within the unlined drawing area. Asmentioned above, the gesture commands are context sensitive, dependenton where they are located, and will cause different things to happen iflocated in the unlined area than if located in the lined area.

FIG. 7Q shows an "insert lines" gesture performed in the left margin,and its effect which was to add three lines following line 2 of thedocument of FIG. 7P. Comparing FIG. 7Q with FIG. 7P, it should be notedthat this command actually added more lines between the previouslyexisting lines, rather than merely shifting the contents of lines 3, 4and 5 downward. The result of this function was to shift the contents ofboth the lined area and unlined area below line 2 downward as a unit.

FIG. 7R contrasts the two functions performed by the insert linesgesture dependent upon where such gesture is performed. In FIG. 7R, theuser has performed the insert lines (actually "insert BOL marker")gesture within the script in one of the lines alongside the drawing. Thefunction corresponding to this gesture command is, as described above,to push the line space contents downstream of the pen down location ofthe gesture onto subsequent lines without moving or otherwise affectingthe drawing. Note also that, during word wrapping, the software comparesthe length of words to the amount of space available in each line todetermine whether there is sufficient space for the word. Thus, the word"character" in FIG. 7Q was too long to fit on the preceding linecontaining the word "unique." Similarly, in FIG. 7R, the word "unique"was too long to fit in the remaining space of the preceding line.

FIG. 7S shows the context sensitive nature of the delete lines gesture.This gesture was performed in both the lined area on the line precedingthe word "operation" as indicated by the sketched arrow at thatlocation, and in the unlined left margin at the location indicated bythe upward-directed arrow in the margin. The delete lines gestureperformed in the lined area shifted the script contents upward by oneline, obliterating the words "gesture (lines)" and the downstream scriptor line contents reflowed upward to fill in the space left by theobliterated line contents. The delete lines gesture performed in themargin shifted all of the lines and the unlined drawing area upward byone line without any reflow of the document. If there had been anycontents in the deleted line, these would have been deleted.

FIG. 7T shows the display after reinvoking the services menu, showingthe rulers where they had previously been placed and collapsing thelines alongside the drawing area (that had previously been designated)to a length essentially equal to zero (actually one pixel in length withthe beginning and end points of each line set equal). This functioncould also be incorporated into an icon. Upon removal of the rulers, thedocument appears as shown in FIG. 7U. Note that when the lines alongsidethe unlined drawing area were shortened, the contents of the line spaceswrapped downward to the first and subsequent lines below the drawingspace. If space or script were added to the lines immediately precedingthe drawing, for example, by using an insert moving space gesture, wordsfrom these lines would wrap across the drawing area to the lines below.

The foregoing summarizes the principal features of the gesture sets andtheir corresponding editing functions. As demonstrated above, thesegestures can be used in various combinations to achieve differentediting results. Other gestures and their corresponding functions arelikewise operative in a consistent manner although not demonstrated inthe foregoing example.

Fast Data Entry Using a Pen

The following describes how to provide pen-based computers with a methodfor fast and accurate text entry. Currently, pen-based computers allowthe user to print characters and words which are then recognized by thecomputer. Some pen-based systems allow the user to hunt for characterson the image of a keyboard displayed on the screen. Neither of thesemethods is particularly fast or accurate--a printed character can bemis-recognized or a word can be misspelled. The method next describedcan be used with any computer that employs a pointing device. Thepointing device is used to choose among a set of characters presented tothe user.

The basic idea revolves around the fact that as each letter of a word isspecified, the possible range of succeeding letters is narrowed in amanner determined probabilistically in the user's language (e.g.,written English). Following an initial letter selection by the user, themost probable next character is presented to the user at a positioncloser to the pointing device than other characters available forconstructing words. This allows the user to move the pointing device theshortest distance in order to specify the characters of a word. It alsoassures that the user ends up with a correctly spelled word because onlythose character sequences that spell words are presented to the user. Anexample is shown in FIG. 10. The initial range of characters ispresented to the user in alphabetical order.

The user wants to spell "zoom" so "z" is touched with the pen, at whichtime the characters "n a e i o u y w" were presented, representing themost probable letters following an initial "z" in English words. Thesecharacters are arranged so that the most probable choices are closest tothe initial "z." The user then touches the letter "o," at which time thecharacters "d m r o u n" are presented. Again these characters arearranged so that the most probable choices are closest to the lastchoice, "o." The user then touches the letter "o" in the latest set ofcharacters and is presented with "zoology zoom zoomlens zoophyte."Rather than another set of characters, the user is provided with theentire set of words that exist containing the character sequence thathas been specified so far. The user has already specified the word "zoo"by touching characters, but since the word "zoom" was desired, the usercompletes the word by touching the word "zoom." Since the pen has beentouching the "paper" for the entire duration of the word specification,the user merely lifts the pen in order for the word to be appended tothe line of text that he is creating. The user can now repeat theprocess to find (get) another word. If, during the word specificationprocess, the user finds that he made a mistake (was heading in the wrongdirection due to a bad preceding character selection), he can backtrackwith the pen to undo preceding character selections.

The set of words available to the user when using this data entryapproach can vary. For instance, the set of words could be restricted tochemical names in certain applications. Additionally, the positioning ofcharacters following the initial character selection could change as thesystem learned the user's preferences for certain words. A simpleimplementation of this learning might be to switch the position of eachcharacter selection with its higher probability neighbor. Then, the moreoften a certain character is used, the closer it is positioned to thepreceding character selection. If the user wants to enter a word that isnot in the current dictionary (set) of words, that word could be spelledby tapping in the proper sequence of the word's characters on theinitial alphabet line.

Having described and illustrated the principles of the invention in apreferred embodiment thereof, it should be apparent that the inventioncan be modified in arrangement and detail without departing from suchprinciples.

I claim all modifications and variation coming within the spirit andscope of the following claims.
 1. A pen-based computer method for a userinteractively to enter and edit script or text using a pen-typeelectrical input device on a dynamic document display having a series oflines defining line spaces for writing script, the methodcomprising:entering script on the document display along at least one ofsaid lines using the input device in a script entry mode; first,gesturing using the input device in a predetermined manner at auser-determined location to indicate commencement of a control gesturemode, the computer and document display being responsive to terminatethe script entry mode and enter the control gesture mode; and second,gesturing using the input device in accordance with a selected one of apredetermined set of gestures to assert a selected control function inthe document at said location, the computer and document display beingresponsive to the selected control function to perform a correspondingfunction on the document display or script entered therein.
 2. A methodaccording to claim 1 in which the second gesturing step includesterminating the selected gesture, the computer and document displaybeing responsive to terminate the control gesture mode and resume thescript entry mode.
 3. A method according to claim 1 in which thepredetermined set of gestures includes a gesture directed along saidlines for indicating insertion or deletion of space lengthwise within aline space at said location.
 4. A method according to claim 3 in whichthe gesture has two alternative directions along the lines, including:afirst direction coinciding with a direction of script entry to which thecomputer and document display is responsive to open additional spacealong a line space, a second direction opposite the direction of scriptentry to which the computer and document display is responsive to closespace and delete any script or text contained in the line space.
 5. Amethod according to claim 3 in which the gesture has a length determinedby the user, to which the computer and document display is responsive toopen or close a corresponding length of space.
 6. A method according toclaim 1 in which the predetermined set of gestures includes a gesturedirected across said lines for indicating insertion or deletion of aline space at said location.
 7. A method according to claim 6 in whichthe gesture has two alternative directions across the lines, including:afirst direction coinciding with a line-to-line direction of script entryto which the computer and document display is responsive to open anadditional line space, and a second direction opposite the direction ofscript entry to which the computer and document display is responsive toclose a line space and obliterate any script or text contained therein.8. A method according to claim 6 in which the gesture has a lengthdetermined by the user, to which the computer and document display isresponsive to open or close a corresponding amount of line spaces.
 9. Amethod according to claim 1 in which the input device includes a stylusand a stylus-sensitive writing surface and the predetermined set ofgestures includes a gesture of moving the stylus out of contact with thewriting surface after the first gesturing step, to which the computerand document display is responsive to open at said location an amount ofadded space which moves lengthwise along the as the user enters scriptin the added line space.
 10. A method according to claim 9 in which theinput device is proximity responsive and the predetermined set ofgestures includes a gesture, made by the user while entering script intosaid added space, of moving the stylus out of proximity of the writingsurface, to which the computer and document display is responsive toscroll the document display to present a next succeeding line space forentry of script.
 11. A method according to claim 9 in which the lineseach have a beginning point and an ending point and, as the user entersscript in a first line space, any subsequent script is pushed ahead ofthe added space and wrapped into a next succeeding line space.
 12. Amethod according to claim 1 in which the input device includes a stylusand a stylus-sensitive writing surface and the first gesturing stepincludes touching the stylus momentarily to said writing surface andsaid second gesture includes moving the stylus in a selected directionin two distinct motions separated by a brief delay, the computer anddocument display being responsive to said momentary touch and delay toterminate the script entry mode and commence the control gesture modeand subsequently being responsive to the second gesturing step toperform said corresponding function.
 13. A method according to claim 1in which the input device includes a stylus and a writing surface whichincludes means for sensing stylus orientation and the first gesturingstep includes positioning the stylus in a predetermined orientationrelative to said writing surface and said second gesture includes movingthe stylus in a selected direction, the computer and document displaybeing responsive to said predetermined orientation of the stylus toterminate the script entry mode and commence the control gesture modeand subsequently being responsive to the second gesturing step toperform said corresponding function.
 14. A context-sensitive methodaccording to claim 1 including:forming the lines in a parallel set witheach line having a beginning point and an ending point on the documentdisplay so that the parallel set of lines collectively defines a linedarea bounded by an unlined margin area; and selecting between the linedarea and unlined margin area for the location of the first gesturingstep; the computer and document display being responsive to the secondgesturing step according to said selected location to assert a selectedcontrol function in the document to perform one of said correspondingfunctions within the lined area or a second function within one of thelined area and unlined area depending on the nature of the selectedcontrol function.
 15. A method according to claim 14 in which thepredetermined set of gestures includes a gesture directed across saidlines for indicating insertion or deletion of a line space at saidlocation, the first function responsive to performing the gesture in thelined area being to shift line space contents downward or upward withinthe line spaces and the second function responsive to performing thegesture in an unlined area alongside the lined area being to insert ordelete lines and line spaces.
 16. A method according to claim 14including:entering script or a drawing in the unlined area; and editingscript or text in an adjoining portion of the lined area in such a waythat some of the script or text is moved; the computer and documentdisplay being responsive to move the edited script or text in the areawhile retaining the script or drawing in the lined area unchanged by theediting step.
 17. A method according to claim 1 in which the computerand document display are responsive to the first gesturing step todisplay a gesture prompt to the user to indicate entry of the controlgesture mode.
 18. A method according to claim 1 in which thepredetermined gesture set and corresponding functions include: Insertspace; Delete space; Insert line; and Delete line.
 19. A methodaccording to claim 1 in which the lines each have a beginning point andan ending point and the predetermined set of gestures includes an InsertMoving Space gesture, to which the computer and document display isresponsive to open at said location an amount of space which moveslengthwise along the line and wraps from line to line as the user entersscript in the added line space.
 20. A method according to claim 19 inwhich the input device includes a stylus and a stylus-sensitive writingsurface which are sensitive to stylus orientation, the first gesturingstep includes positioning the stylus in an orientation approximatelynormal to the writing surface, and the Insert Moving Space gestureincludes the gesture of placing the stylus in contact with the writingsurface after the first gesturing step, and commencing to write in themoving line space.
 21. A pen-based computer method for a userinteractively to enter and edit hand written script using a pen-typeelectrical input device on a dynamic document display, the methodcomprising:forming a series of lines, each having a beginning point andan end point, to define line spaces for writing script; entering aplurality of script strokes along said line spaces on the documentdisplay using the input device in a script entry mode; delineatingseparate sets of adjacent script strokes as a word extending from afirst break point marker through the line space consumed by all strokesprior to a second break point marker; performing an editing function onthe words such that one or more of the words are moved along a line to adifferent line space; and wrapping the moved words between the end andbeginning points of successive line spaces.
 22. A method according toclaim 21 wherein the delineating step includes identifying a variablegap between strokes and comparing the gap with a predefined break pointgap value.
 23. A method according to claim 22 wherein the delineatingstep further includes a user explicitly defining the break point gapvalue.
 24. A method according to claim 21 wherein the wrapping stepfurther includes:detecting the presence of a script stroke crossing anend point of a line; parsing backward through the database of scriptstrokes to locate a breakpoint marker; wrapping forward all scriptstrokes succeeding said marker to the succeeding line space; andrecursively applying the preceding steps to the remaining script strokesuntil all words and text fit within the designated line spaces.
 25. Amethod according to claim 24 wherein the wrapping forward step includesmaintaining the amount of white space separating the wrapped scriptstrokes from the script strokes retained on the preceding line space.26. A method according to claim 21 wherein the wrapping step furtherincludes:detecting the presence of white space at the end of a precedingline space; parsing forward through the database of script strokesbeginning at the next line space to locate a breakpoint marker followingthe last stroke that, when combined with the WrapGap for the line andthe line space used by the strokes preceding it, fits into the whitespace at the end of the preceding line space; wrapping backward allscript strokes preceding said marker to the preceding line space; andrecursively applying the preceding steps to the remaining white spaceuntil all words that can be wrapped backward to fill white space havebeen wrapped backward.
 27. A method according to claim 26 wherein thewrapping backward step includes maintaining the amount of white spaceseparating the wrapped script strokes from the script strokes retainedon the present line space.
 28. A method according to claim 21 includingplacing a beginning of line (BOL) marker in a selected line space and,responsive to the BOL marker, preventing wrapping of the moved word intothe line space containing the BOL marker.
 29. A method according toclaim 28 including opening a new line space preceding the linecontaining the BOL marker and wrapping the moved word into the new linespace.
 30. A method according to claim 21 including intermingling glyphsof two or more of binary encoded text, handwritten script and bitmappedimages, and wrapping the intermingled glyphs in a continuous serialstream.
 31. A pen-based computer method for a user interactively toenter and edit script and ASCII-like text and any series of points usinga pen-type electrical input device means on a dynamic document displaymeans, the method comprising:forming a series of lines, each having abeginning point and an end point, to define line spaces for writingscript; entering data point combinations including series of adjacentscript strokes along said line spaces on the document display using theinput device mean in a script entry mode; entering one or moreASCII-like text character along said line spaces on the documentdisplay; delineating combinations of adjacent script strokes andSCII-like characters as words extending from a break point markerthrough the area consumed by all strokes and/or ASCII-like charactersprior to a subsequent break point marker; performing an editing functionon the words entered therein such that words are moved to different linespaces; and wrapping the moved words between the end point and beginningpoint of successive line spaces.
 32. A method according to claim 31wherein the word wrapping step further includes:detecting the presenceof script strokes or ASCII test crossing an end-of-line boundary;parsing backward through the database of script strokes to locate abreakpoint gap marker; wrapping forward all script strokes and ASCIItext succeeding said marker to the succeeding line space; andrecursively applying the preceding step to the remaining script strokesand ASCII text until all words fit within the designated line spaces.33. A method according to claim 32 wherein the wrapping forward stepincludes maintaining an amount of white space separating the wrappedscript strokes from the script strokes retained on the preceding linespace.
 34. A method according to claim 31 wherein the word wrapping stepfurther includes:detecting the presence of white space at the end of apreceding line space; parsing forward through the data base of scriptstrokes and ASCII text beginning at the next line space to locate thebreakpoint gap marker following the last stroke or ASCII character that,when combined with a WrapGap value for the line and the line space usedby the strokes or ASCII text preceding it, fits into the white space atthe end of the preceding line space; wrapping backward all scriptstrokes and ASCII characters preceding said marker to the preceding linespace; and recursively applying the preceding steps to the remainingwhite space until all script strokes and ASCII text that can be wrappedbackward to fill white space have been wrapped backward.
 35. A methodaccording to claim 34 wherein the wrapping backward step includesmaintaining the amount of white space separating the wrapped scriptstrokes from the script strokes and ASCII retained on the present linespace.
 36. A pen-based computer method for a user interactively to enterscript using a pen-type electrical input device on a dynamic documentdisplay, the method comprising:forming a series of liens, each having abeginning point and an end point, to define lien spaces for writingscript; entering data, comprising one or more of binary encoded text,handwritten script, bitmapped images and drawing strokes, along saidline spaces on the document display; demarcating the data as a series ofwork-like units having a first user-determined spacing separating eachunit, the first spacing being variable over a finite range greater thana predetermined minimum spacing; positioning a selected unit at asecond, variable user-determined spacing from a preceding unit greaterthan the first spacing; and encoding each of said first and second wordspacings in terms of a relative location of each unit in associationwith a portion of the data defining each unit; performing an editingfunction on the units such that one or more of the units are moved to adifferent line space; and maintaining said first and second spacingduring the movement of the units.
 37. A method according to claim 36including wrapping one or more of the moved units across the end andbeginning points of successive line spaces and maintaining theirrespective spacings.
 38. A method according to claim 37 includingcomparing a first length define by each unit nd its respective spacingwith a second length of available line space in the successive linespace and wrapping the unit and its respective spacing into thesuccessive line space if the first length does not exceed the secondlength.
 39. A method according to claim 38 including reducing thespacing to not less than the predetermined minimum spacing if the firstlength exceeds the second length and if such reduction in spacing willenable wrapping of the unit and its spacing into the successive linespace.
 40. A method according to claim 36 including:interpretingplacement of one of the units at the second spacing from the beginningpoint of one of the line spaces as an indentation defining a beginningof a new line of units; encoding a beginning of line marker in the datain the line space containing the marker; wrapping one or more of themoved units from a preceding line space across the end and beginningpoints of successive line spaces; and opening a new line space betweenthe line space containing the marker and the immediately preceding linespace to receive units moved from said immediately preceding line space.41. In a pen-based computer having a user-operable pen-type electricalinput device, a dynamic document display comprising:a dynamic displaywindow; a page formatted on the display window with top, bottom, leftand right page boundaries; a group of lines arranged in a parallel,spaced-apart manner on the page, each line having beginning and endingpoints defining a length of each line; and line space segments betweenthe lines, each line space segment bounded widthwise by a pair ofadjacent lines and lengthwise by the length of one of the lines; thelines space segments each including a matrix of data points forreceiving and displaying data therein, and being coupled in series so asto establish continuity of the line space segments from an endpoint of afirst line to a beginning point of a second line; electrical means ofinputting script or bitmapped image data for display in the data points;and means responsive to a user operation of the input device forshifting a portion of the data displayed in the data points lengthwisealong one of the line space segments and serially across the end pointof the first line and beginning point of the second line to a seriallyadjoining line space segment.
 42. A document display according to claim41 in which the data points are organized into separable units havingfirst and last points defining a length of the unit, the shifting meansbeing operative to shift each unit as a unit, including all data pointsbetween the first and last points, across the beginning and endingpoints of lines to the adjoining line space segment.
 43. A documentdisplay according to claim 42 including means for entering a beginningof line (BOL) marker at the beginning point of the second line, theshifting means being responsive to the BOL marker to shift the BOLmarker and the data points in the line space segment at the second lineto a third line.
 44. A document display according to claim 42 in whichthe shifting means includes means for comparing the length of the unitto be shifted with the length of the adjoining line segment and, if theunit length is longer than the length of the adjoining line segment,shifting the unit of data points to a third line.
 45. A document displayaccording to claim 41 in which the page is formatted on the displaywindow with a margin along one or more of the top, bottom, left andright page boundaries, including a margin adjoining one of the beginningand ending points of the lines having a width that can be variedinversely with the lengths of the lines, the margin defining a drawingspace that is nonresponsive to said means responsive to a user actionfor shifting a portion of the data displayed in the data pointslengthwise along one of the line space segments.
 46. A pen-basedcomputer method for a user interactively to enter and edit script ortext using a pen-type electrical input device on a dynamic documentdisplay, the method comprising:forming a series of lines, each having abeginning point and an end point, to define line spaces for writingscript; entering data, comprising one or more of binary encoded text, abitmapped image handwritten script and drawing strokes, along said linespaces on the document display; demarcating the data as a series ofglyphs having a spacing separating each unit; encoding the data for eachglyph in a manner that enables storage, retrieval and display thereof;and encoding with the data for each glyph a starting point, a left-mostposition point and a right-most position point for the glyph.
 47. Amethod according to claim 46 in which the glyph is an ASCII characterand the data for the glyph is maintained in binary encoded ASCII format.48. A method according to claim 46 in which the glyph is a handwrittenstroke and the data for the glyph is compression encoded in a formatthat permits substantial replication of the stroke.
 49. A pen-basedcomputer method for a user interactively to enter and edit hand writtenscript using a pen-type electrical input device on a dynamic documentdisplay, the method comprising:entering a plurality of script strokes ina series along a line on the document display using the input device ina script entry mode; identifying a variable gap between strokes andcomparing the gap with a predefined break point gap value to locate abreakpoint marker when the gap between strokes exceeds said value;delineating separate sets of adjacent script strokes in said series as aseries of words, each word extending from a first break point markerthrough all the strokes prior to a second break point marker; andperforming an editing function on the words such that one or more of thewords are manipulated as units.